package com.school.oa.service.impl;

import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Service;


@Service
public class RedisServiceImpl {
	
	@Autowired
	private RedisTemplate redisTemplate;
	
	/**
	 * 写入缓存
	 * @param key
	 * @param value
	 * @return
	 */
	public boolean set(final String key, Object value) {
		boolean result = false;
		try {
			ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
			operations.set(key, value);
			result = true;
		} 
		catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}
	
	/**
	 * 写入缓存设置时效时间
	 * @param key
	 * @param value
	 * @param expireTime
	 * @return
	 */
	public boolean set(final String key, Object value, Long expireTime) {
		boolean result = false;
		try {
			ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
			operations.set(key, value);
			redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
			result = true;
		}
		catch(Exception e) {
			e.printStackTrace();
		}
		return result;
	}
	
	/**
	 * 批量删除key
	 * @param pattern
	 */
	public void removePattern(final String pattern) {
		Set<Serializable> keys = redisTemplate.keys(pattern);
		if(keys.size()>0)
			redisTemplate.delete(keys);
	}
	
	/**
	 * 删除对应的value
	 * @param key
	 */
	public void remove(final String key) {
		if(exists(key)) {
			redisTemplate.delete(key);
		}
	}
	
	/**
     * 判断缓存中是否有对应的value
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }
    
    /**
     * 读取缓存
     * @param key
     * @return
     */
    public Object get(final String key) {
    	Object result = null;
    	ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
    	result = operations.get(key);
    	return result;
    }
    
    /**
     * 哈希 添加
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value) {
    	HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
    	hash.put(key, hashKey, value);
    }
    
    /**
     * 哈希获取数据
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey) {
    	HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
    	return hash.get(key, hashKey);
    }
    
    /**
     * 列表添加
     * @param key
     * @param value
     */
    public void lPush(String key, Object value) {
    	ListOperations<String, Object> list = redisTemplate.opsForList();
    	list.rightPush(key, value);
    }
    
    /**
     * 列表获取
     * @param k
     * @param l
     * @param ll
     * @return
     */
    public List<Object> lRange(String k,long l,long ll){
    	ListOperations<String, Object> list = redisTemplate.opsForList();
    	return list.range(k, l, ll);
    }
    
    /**
     * 集合添加
     * @param key
     * @param value
     */
    public void add(String key, Object value){
    	SetOperations<String, Object> set = redisTemplate.opsForSet();
    	set.add(key,value);
    }
    
    /**
     * 集合获取
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key){
    	SetOperations<String, Object> set = redisTemplate.opsForSet();
    	return set.members(key);
    }
    
    /**
     * 有序集合添加
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key, Object value, double scoure) {
    	ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
    	zset.add(key, value, scoure);
    }
    
    /**
     * 有序集合获取
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key, double scoure, double scoure1){
    	 ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
         return zset.rangeByScore(key, scoure, scoure1);
    }
}
